home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 078 (1988-11-15)(Ossowski, Stefan)(DE)(PD).zip / Taifun 078 (1988-11-15)(Ossowski, Stefan)(DE)(PD).adf / Edi / edi-druck.c < prev    next >
C/C++ Source or Header  |  1988-08-14  |  11KB  |  399 lines
  1. /******************************************************************
  2.                            EDI-druck
  3.  
  4.     Programm, das alles, was über die PIPE:edi-druck angeliefert 
  5.     wird, auf den Drucker ausgibt und die in der Datei        
  6.     "s:edi-ersetz" aufgeführten Makros durch entsprechende 
  7.     Steuerzeichen ersetzt. Das Programm beendet sich selbst, wenn 
  8.     es den ASCII-Wert 128 aus der PIPE: liest. 
  9.  
  10.     In der ersten Zeile können einige Parameter übergeben werden,
  11.     wenn diese mit einem "%"-Zeichen beginnt. Dazu gehören die 
  12.     Anzahl der Zeilen pro Seite, eine Seiten-Nummerierung, sowie
  13.     ein automatisches Überspringen der Perforation
  14.  
  15. ******************************************************************/
  16.  
  17. #include "exec/tasks.h"
  18. #include "exec/memory.h"
  19. #include "intuition/intuitionbase.h"
  20. #include "stdio.h"
  21.  
  22. #define LF                    10  /* LF = Zeilenende !! */
  23. #define FF                    12  /* LF = Zeilenende !! */
  24. #define UNGLEICH              !=         
  25. #define ABBRUCH               break
  26. #define ZUM_LESEN             "r"
  27. #define ZUM_SCHREIBEN         "w"
  28. #define TEST_DATEI            "test.text"
  29. #define BOOL                  int
  30. #define ULONG                 unsigned long
  31. #define UBYTE                 unsigned char
  32.  
  33. #define DEFAULTL 62          /* default: Zeilen pro Seite */
  34. #define DEFAULTS 1           /* default: erste Seitennummer */
  35. #define DEFAULTZ 1           /* default: erste Zeilennummer */
  36. #define LF       10          /* LineFeed */
  37. #define FF       12          /* Formfeed */
  38. #define PRINTER  "prt:" /* Bezeichnung der Printerschnittstelle */
  39. /* Makro, um eine Textzeile auszugeben */
  40. #define putline(pointer,text)   fputs(text,pointer)
  41.  
  42. UBYTE zeile[120]; 
  43. UBYTE einwort[40];
  44.  
  45. struct string 
  46. {
  47.    int     laenge;        /* Länge des Suchwortes */
  48.    ULONG   maske;         /* Maske zum verUNDen des hashcode */
  49.    ULONG   hashcode;      /* hashcode des Strings in 4-Bit-Gruppen */
  50.    UBYTE   worte[20];     /* zu suchendes Wort */
  51.    int     elaenge;       /* Länge des Ersatzwortes */
  52.    UBYTE   eworte[20];    /* damit wird ersetzt */
  53. };
  54.  
  55. int anzahl;               /* enthält die Anzahl der zu suchenden Wörter */
  56. struct string feld[100];  /* Zwischenpuffer für eine Zeile */
  57.  
  58. UBYTE filename[80] = "s:edi-ersetz";
  59.                           /* String, der die auszulesende Datei bezeichnet */
  60. int Seiten = 0;           /* Zähler für die Seitennummer */
  61. int Zeilen = 0;           /* Zähler der Zeilennummer */
  62. int Laenge = DEFAULTL;    /* Länge einer Seite in Zeilen */
  63. int Zaehler = 0;          /* Zählt die ausgedruckten Zeilen */
  64. BOOL ers_flag = FALSE;
  65.  
  66. struct Task *maintask,*FindTask();
  67. UBYTE* oldname;
  68.  
  69. UBYTE *puffer,*makepuffer(),getline();
  70.  
  71. main()
  72. {
  73.     FILE *fpout,*fopen(),*fp = 0L;
  74.  
  75.     BOOL puffer_flag;
  76.     int zaehler,zaehler1;
  77.     int zlaenge;
  78.     UBYTE *pointtoit,*pointtonext; 
  79.     struct string *now;
  80.     ULONG hash_it;
  81.  
  82.     puffer_flag = FALSE;
  83.  
  84.     if ((fpout = fopen(PRINTER,ZUM_SCHREIBEN)) == NULL)
  85.     {  melde("PRT: ist nicht bereit",FALSE);
  86.        exit(20);
  87.     }
  88.  
  89.     maintask = FindTask(0L);
  90.     oldname = (UBYTE *)maintask->tc_Node.ln_Name;
  91.     maintask->tc_Node.ln_Name = "edi-druck";
  92.  
  93.     puffer = makepuffer(); 
  94.     if (puffer != 0L) 
  95.        puffer_flag = TRUE;
  96.     else
  97.        if ((fp = fopen("PIPE:edi-druck",ZUM_LESEN)) == NULL)
  98.        {  melde("PIPE: nicht installiert",FALSE);
  99.           fclose(fpout); killpuffer();
  100.           exit(20);
  101.        }
  102.  
  103.  
  104.     zlaenge = hole_zeile(fp,zeile);
  105. /*    fprintf(stderr,"%s\n%d\n%.20s\n",zeile,zlaenge,puffer);*/
  106.     zeile_mit(fp,zeile,&zlaenge);
  107.  
  108.     if (ers_flag)
  109.     {
  110.        if (init_worte() != 0)
  111.        {  goto raus;
  112.        } 
  113.  
  114.        do         /* wiederhole folgendes für eine Zeile */
  115.        {  hash_it = 0L; pointtonext = pointtoit = zeile;
  116.    
  117.           for (zaehler1 = 0; zaehler1 < zlaenge; zaehler1 ++)
  118.           {  hash_it = (hash_it << 4) + ((*pointtonext++) & 0x0f);  
  119.                            /* Achtung '<<' ist Compiler-spezifisch !! */
  120.                            /* es MUß geschoben nicht rotiert werden */
  121.              for (zaehler = 0; zaehler < anzahl; zaehler++)
  122.              {  now = &(feld[zaehler]);
  123.                 if (now->hashcode ==  (now->maske & hash_it)) 
  124.                 {  if (strncmp(now->worte, pointtoit-now->laenge+1,
  125.                                now->laenge) == 0)
  126.                    {  
  127.                       zlaenge = ersetze(zaehler1-now->laenge+1,now,zlaenge);
  128.                       hash_it = 0L; pointtonext = zeile;
  129.                       pointtoit = zeile-1;
  130.                       zaehler1 = -1; 
  131.                       break;
  132.                    }
  133.                 }
  134.              }
  135.              pointtoit++;
  136.           }
  137.           gibaus(fpout,zeile); 
  138.        }  while ((zlaenge = hole_zeile(fp,zeile)) UNGLEICH -1); 
  139.           /* ... bis alle Zeilen gelesen */
  140.     }
  141.     else
  142.        druckepur(fp,fpout);
  143.   
  144.     fputc(FF,fpout);               /* letzte Seite rausschieben */
  145.   
  146. raus:
  147.     maintask->tc_Node.ln_Name = (char *)oldname;
  148.     if (puffer != NULL) 
  149.        killpuffer();
  150.     else
  151.        fclose(fp);
  152.     fclose(fpout);        /* "Dateien" wieder schließen */
  153. }
  154.  
  155. hole_zeile(fp,text)
  156. FILE *fp;
  157. UBYTE *text;
  158. {
  159.      register int ein; register int zaehler = 0;
  160.      register UBYTE pein;
  161.  
  162.      if (puffer != NULL)
  163.      {  
  164.         while ((pein = getline()) != LF && pein != '\0')
  165.            text[zaehler++] = (UBYTE) pein;   /* kopieren und weiter */
  166.         if (pein == '\0') 
  167.            ein = EOF;
  168.         else
  169.            ein = pein;
  170.      }
  171.      else
  172.      {  while ((ein = fgetc(fp))!= LF && ein != EOF)
  173.            text[zaehler++] = (UBYTE) ein;    /* kopieren und weiter */
  174.      }
  175.  
  176.      text[zaehler] = '\0';  /* Zeichenkette mit 0 abschließen */
  177.      if (ein == EOF && zaehler == 0) return -1;
  178.      return zaehler;    /* -1, wenn kein Zeichen gelesen werden konnte */
  179. }
  180.  
  181. init_worte()
  182. {
  183.     int i,j,c,laenge; FILE *fpin;
  184.  
  185.     fpin = fopen(filename,ZUM_LESEN);
  186.  
  187.     if (fpin == NULL) 
  188.     {  sprintf(zeile,"'%s' geht nicht auf",filename);
  189.        melde(zeile,FALSE);
  190.        return 1;
  191.     }
  192.     i = 0;
  193.     do
  194.     {  j = 0; 
  195.        if ((c = fgetc(fpin)) == EOF) 
  196.           break;     /* ein Wort lesen */
  197.        c = getdez(feld[i].worte,&(feld[i].laenge),fpin,c);
  198.        if (c == EOF) 
  199.           break;
  200.        while ((c = fgetc(fpin))== ' ') ;   /* Leerzeichen überlesen */
  201.  
  202.        c = getdez(feld[i].eworte,&(feld[i].elaenge),fpin,c);
  203.  
  204.        laenge = (feld[i].laenge) > 8 ? 8 : feld[i].laenge; 
  205.                   /* nicht länger als 8 Zeichen */
  206.        if (laenge == 0) continue;
  207.        feld[i].maske    = 0x000fL;
  208.        feld[i].hashcode = feld[i].worte[0] & 0x000fL;
  209.  
  210.        for (j=1; j < laenge; j++)
  211.        {   feld[i].maske = (feld[i].maske << 4) + 0x000fL;
  212.            feld[i].hashcode = (feld[i].hashcode << 4) + 
  213.                                 (feld[i].worte[j] & 0x000f);
  214.        }
  215.  
  216.        while (c != LF && c != EOF)
  217.           c = fgetc(fpin);
  218.        i++;
  219.     }  while (c != EOF);
  220.  
  221.     anzahl = i;
  222.  
  223.     fclose(fpin); return 0;
  224. }
  225.  
  226. ersetze(posi,zeiger,zlen)
  227. int posi;
  228. struct string *zeiger;
  229. int zlen;
  230. {   register int i,j; UBYTE *p = zeile + posi;
  231.  
  232.     if (zeiger->laenge > zeiger->elaenge)
  233.     {  strncpy(p,zeiger->eworte,zeiger->elaenge);
  234.        strcpy(p+zeiger->elaenge, p+zeiger->laenge);
  235.        return(zlen-zeiger->laenge+zeiger->elaenge);
  236.     } 
  237.  
  238.     if (zeiger->laenge == zeiger->elaenge)
  239.     {  strncpy(zeile+posi,zeiger->eworte,zeiger->elaenge);
  240.        return(zlen);
  241.     }
  242.     
  243.     j = zeiger->elaenge-zeiger->laenge;
  244.     for (i = zlen +j; i >= posi+zeiger->elaenge; i--)
  245.        zeile[i] = zeile[i-j];
  246.     strncpy(zeile+posi,zeiger->eworte,zeiger->elaenge);
  247.     return(zlen+j);
  248. } 
  249.  
  250. druckepur(fp,fpout)
  251. long fp,fpout;
  252. {
  253.    gibaus(fpout,zeile);
  254.  
  255.    while (hole_zeile(fp,zeile) UNGLEICH -1)
  256.       gibaus(fpout,zeile);
  257. }
  258.      
  259. gibaus(fp,zeile)
  260. long fp;
  261. UBYTE *zeile;
  262. {   
  263.    if (Zeilen)                    /* wenn Zeilennumern erwünscht */
  264.       fprintf(fp,"%4d  ",Zeilen++);
  265.  
  266.    putline(fp,zeile);                          /* Zeile ausgeben */
  267.    fputc('\n',fp);                         /* Linefeed hinterher */
  268.  
  269.    if ((++Zaehler % Laenge) == 0)            /* prüfe Seitenende */
  270.    {  if (Seiten)                          /* wenn Seitennummern */
  271.       {  putline(fp,"\x0A                                   Seite "); 
  272.          fprintf(fp,"%3d\n",Seiten++);          /* ausgeben + LF */
  273.       }                            /* neue Zeilennummer ausgeben */
  274.       if (Laenge != 72)                         /* am Seitenende */
  275.          fputc(FF,fp);                      /* Formfeed ausgeben */
  276.    }
  277. }
  278.  
  279. int getdez(wort,laenge,fpin,c) 
  280. UBYTE *wort;
  281. int *laenge,c;
  282. FILE *fpin;
  283. {
  284.    int j = 0;
  285.    while (c != ' ' && c != '\n' && c != EOF) 
  286.    {  
  287.       if (c == '/')                 /* folgt ein Dezimalwert ? */
  288.       {  c = (fgetc(fpin)-48)*10;
  289.          c = (c + (fgetc(fpin)-48))*10;       /* herausfiltern */
  290.          c += fgetc(fpin)-48;
  291.       }
  292.       wort[j++] = (UBYTE) (255 & c);  /* und speichern */
  293.       c = fgetc(fpin);
  294.    }
  295.    wort[j] = '\0';   *laenge = j;
  296.  
  297.    return c;
  298. }
  299.  
  300. struct IntuiText weiter = { (UBYTE)0,(UBYTE)0,(UBYTE)JAM1,
  301.                             (SHORT)5,(SHORT)3,NULL,(UBYTE*)"weiter", 0L } ;
  302. struct IntuiText abbruch = { (UBYTE)0,(UBYTE)0,(UBYTE)JAM1,            
  303.                             (SHORT)5,(SHORT)3,NULL,(UBYTE*)"abbruch",0L } ;
  304. struct IntuiText showt  = { (UBYTE)0,(UBYTE)0,(UBYTE)JAM1,            
  305.                             (SHORT)20,(SHORT)10,NULL,(UBYTE*)0L , 0L } ;
  306.  
  307. struct IntuitionBase *IntuitionBase, *OpenLibrary();
  308.  
  309. melde(text,flag)
  310. UBYTE* text;
  311. BOOL flag;
  312. {
  313.     long ergibt = 0L,AutoRequest();
  314.     UBYTE *speicher,*AllocMem();
  315.     struct Window* win;
  316.  
  317.     IntuitionBase = OpenLibrary("intuition.library",0L);
  318.     if (IntuitionBase != NULL)
  319.     {  win = IntuitionBase->ActiveWindow;
  320.        showt.IText = text; 
  321.        ergibt = AutoRequest(win,&showt,flag ? &weiter:NULL,&abbruch,0L,0L,
  322.                 (long)IntuiTextLength(&showt)+80L,60L);
  323.        CloseLibrary(IntuitionBase);
  324.     }
  325.     return ergibt;
  326. }
  327.  
  328. zeile_mit(fp,zeile,zlaenge)
  329. FILE *fp;
  330. UBYTE *zeile;
  331. int *zlaenge;
  332. {
  333.     UBYTE *pointit,c,*index();
  334.     int j; 
  335.  
  336.     if (*zeile != '%') return;
  337.  
  338.     if (pointit = index(zeile,'Z'))
  339.       if ((Zeilen = atoi(++pointit)) == 0)
  340.           Zeilen = DEFAULTZ;
  341.     if (pointit = index(zeile,'S'))
  342.       if ((Seiten = atoi(++pointit)) == 0)
  343.           Seiten = DEFAULTS;
  344.     if (pointit = index(zeile,'L'))
  345.       if ((Laenge = atoi(++pointit)) == 0)
  346.           Laenge = DEFAULTL;
  347.     if (pointit = index(zeile,'D'))
  348.     {  ers_flag = TRUE; j = 0;
  349.        while ((c = *(++pointit)) != ' ' && c != '\n' && c != '\0')
  350.           filename[j++] = c;
  351.        if (j>0) filename[j] = '\0';
  352.     }
  353.     *zlaenge = hole_zeile(fp,zeile);
  354. }
  355.  
  356. long lenne;
  357.  
  358. UBYTE *makepuffer()
  359. {
  360.    UBYTE * AllocMem();
  361.    register UBYTE *zeiger; 
  362.    long len; 
  363.    register int c;
  364.    int filedesk;
  365.  
  366.    filedesk = open("PIPE:edi-druck",0); /* zum lesen */
  367.  
  368.    if (read(filedesk,&len,4L) != 4L)
  369.       return NULL;
  370.    lenne = len+100L;
  371.  
  372.    if ((puffer = AllocMem(lenne,MEMF_PUBLIC|MEMF_CLEAR)) == NULL)
  373.    {  close(filedesk);
  374.       return NULL;
  375.    }
  376.    zeiger = puffer;
  377.  
  378.    read(filedesk,puffer,len);
  379.    puffer[len] = '\0';
  380.  
  381.    close(filedesk);
  382.    return puffer;
  383. }
  384.  
  385. killpuffer()
  386. {
  387.    FreeMem(puffer,lenne);
  388. }
  389.  
  390. UBYTE getline()
  391. {
  392.    static UBYTE *zeiger = 0L;
  393.  
  394.    if (puffer[zeiger] != '\0')
  395.       return puffer[zeiger++];
  396.    else
  397.       return '\0';
  398. }   
  399.